{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 包的导入\n",
    "需要注意的是将tqdm 改为tqdm.notebook，从而在notebook环境下获得更好的体验。因为导入tqdm的话，会发生进度条打印多次的情况，体验很不好"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os \n",
    "import pandas as pd \n",
    "from PIL import Image\n",
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "from torchvision import transforms,models,utils\n",
    "from tqdm.notebook import tqdm\n",
    "# from tqdm import tqdm_notebook as tqdm\n",
    "from torch import nn\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.optim as optim\n",
    "from torch.utils.tensorboard import SummaryWriter \n",
    "# from torchvision import datasets, transforms,utils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "相关文件路径配置，在pycharm项目中将相关路径的配置都统一放在config.py中来管理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_path = 'D:/AIdata/dog vs cat/train'\n",
    "test_path = 'D:/AIdata/dog vs cat/test1'\n",
    "data_root = 'D:/AIdata/dog vs cat/'\n",
    "csv_path = './submission_valnet.csv'\n",
    "tensorboard_path='C:/Users/BraveY/Documents/BraveY/AI-with-code/dog-vs-cat/tensorboard'\n",
    "model_save_path = 'C:/Users/BraveY/Documents/BraveY/AI-with-code/dog-vs-cat/modelDict/dogs-vs-cats-notebook.pth'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据集的创建\n",
    "因为Kaggle官方提供的是[原始数据](https://www.kaggle.com/c/dogs-vs-cats-redux-kernels-edition/data)，不像之前的手写数字数据集可以从pytorch中直接下载已经处理过的数据集，可以直接将数据放入模型进行训练。因此需要我们自己实现数据集的生成。\n",
    "\n",
    "数据集生成的总体思路是继承torch.utils.data.Dataset这个类，自己实现__getitem__和__len__这两个私有方法来完成对我们自己数据的读取操作。其中__getitem__这个函数的主要功能是根据样本的索引，返回索引对应的一张图片的图像数据X与对应的标签Y，也就是返回一个对应的训练样本。__len__这个函数的功能比较简单直接返回数据集中样本的个数即可。\n",
    "\n",
    "具体而言，__getitem__的实现思路比较简单，将索引idx转换为图片的路径，然后用PIL的Image包来读取图片数据，然后将数据用torchvision的transforms转换成tensor并且进行Resize来统一大小（给出的图片尺寸不一致）与归一化，这样一来就可以得到图像数据了。因为训练集中图片的文件名上面带有猫狗的标签，所以标签可以通过对图片文件名split后得到然后转成0,1编码。\n",
    "\n",
    "在获取标签的时候，因为官方提供的测试数据集中并没有猫狗的标签，所以测试集的标签逻辑稍有不同。我的做法是使用一个train标志来进行区分，对于测试的数据，直接将测试样本的标签变成图片自带的id，这样方便后面输出提交的csv文件。因为测试样本不用计算loss，所以将标签置为id是没问题的。\n",
    "\n",
    "为了实现将idx索引转换成图片路径，需要在__init__()函数中将所有的图片路径放在一个list中，这可以用os.listdir()来实现，然后就可以根据索引去获得路径了。\n",
    "\n",
    "需要注意的是，之所以__getitem__()需要根据索引来返回样本，是因为训练数据并不是一次性将所有样本数据加载到内存中，这样太耗内存。而是只用加载对应batch中的一部分数据，所以通过索引来加载送入模型中的一批数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyDataset(Dataset):\n",
    "    def __init__(self, data_path:str, train=True, transform=None):\n",
    "        self.data_path = data_path\n",
    "        self.train_flag = train\n",
    "        if transform is None:\n",
    "            self.transform = transforms.Compose(\n",
    "            [\n",
    "                transforms.Resize(size = (224,224)),#尺寸规范\n",
    "                transforms.ToTensor(),   #转化为tensor\n",
    "                transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n",
    "            ])\n",
    "        else:\n",
    "            self.transform = transform\n",
    "        self.path_list = os.listdir(data_path)\n",
    "    def __getitem__(self, idx: int):\n",
    "        # img to tensor and label to tensor\n",
    "        img_path = self.path_list[idx]\n",
    "        if self.train_flag is True:\n",
    "            if img_path.split('.')[0] == 'dog' : \n",
    "                label = 1\n",
    "            else:\n",
    "                label = 0\n",
    "        else:\n",
    "            label = int(img_path.split('.')[0]) # split 的是str类型要转换为int\n",
    "        label = torch.as_tensor(label, dtype=torch.int64) # 必须使用long 类型数据，否则后面训练会报错 expect long\n",
    "        img_path = os.path.join(self.data_path, img_path)\n",
    "        img = Image.open(img_path)\n",
    "        img = self.transform(img)\n",
    "        return img, label\n",
    "    def __len__(self) -> int:\n",
    "        return len(self.path_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "测试一下，确保Dataset可以正常迭代"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "51895dc0b7b0458ba0eed86136dd20c3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=25000), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([[[ 0.5922,  0.6078,  0.6392,  ...,  0.9216,  0.8902,  0.8745],\n",
      "         [ 0.5922,  0.6078,  0.6392,  ...,  0.9216,  0.8980,  0.8824],\n",
      "         [ 0.5922,  0.6078,  0.6392,  ...,  0.9216,  0.9059,  0.8902],\n",
      "         ...,\n",
      "         [ 0.2078,  0.2157,  0.2235,  ..., -0.9765, -0.9765, -0.9765],\n",
      "         [ 0.2000,  0.2000,  0.2078,  ..., -0.9843, -0.9843, -0.9843],\n",
      "         [ 0.1843,  0.1922,  0.2000,  ..., -0.9922, -0.9922, -0.9922]],\n",
      "\n",
      "        [[ 0.2863,  0.3020,  0.3333,  ...,  0.6000,  0.5843,  0.5686],\n",
      "         [ 0.2863,  0.3020,  0.3333,  ...,  0.6000,  0.5922,  0.5765],\n",
      "         [ 0.2863,  0.3020,  0.3333,  ...,  0.6000,  0.6000,  0.5843],\n",
      "         ...,\n",
      "         [-0.0353, -0.0275, -0.0196,  ..., -0.9765, -0.9765, -0.9765],\n",
      "         [-0.0431, -0.0431, -0.0353,  ..., -0.9843, -0.9843, -0.9843],\n",
      "         [-0.0588, -0.0510, -0.0431,  ..., -0.9922, -0.9922, -0.9922]],\n",
      "\n",
      "        [[-0.3176, -0.3020, -0.2706,  ..., -0.0588, -0.0431, -0.0510],\n",
      "         [-0.3176, -0.3020, -0.2706,  ..., -0.0510, -0.0431, -0.0431],\n",
      "         [-0.3176, -0.3020, -0.2706,  ..., -0.0431, -0.0275, -0.0353],\n",
      "         ...,\n",
      "         [-0.5608, -0.5529, -0.5451,  ..., -0.9922, -0.9922, -0.9922],\n",
      "         [-0.5686, -0.5686, -0.5608,  ..., -1.0000, -1.0000, -1.0000],\n",
      "         [-0.5843, -0.5765, -0.5686,  ..., -1.0000, -1.0000, -1.0000]]]), tensor(0))\n"
     ]
    }
   ],
   "source": [
    "train_ds = MyDataset(train_path)\n",
    "test_ds = MyDataset(test_path,train=False)\n",
    "for i, item in enumerate(tqdm(train_ds)):\n",
    "#     pass\n",
    "    print(item)\n",
    "    break\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据集划分\n",
    "如前面所述，因为官方测试集没有标签，而且提交结果上去后只有一个log loos来作为分值，没有准确率的结果。所以为了得到准确率这个指标，需要新建个有标签的验证集来查看准确率。\n",
    "\n",
    "实现思路是使用torch.utils.data.random_split(),来将官方提供训练数据集划分出一部分的验证集。我的比例是80%的训练集，20%的验证集\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_ds = train_ds\n",
    "train_size = int(0.8 * len(full_ds))\n",
    "validate_size = len(full_ds) - train_size\n",
    "new_train_ds, validate_ds = torch.utils.data.random_split(full_ds,[train_size, validate_size])#数据集划分"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据加载\n",
    "我们制作的数据集并不能直接放入模型进行训练，还需要使用一个数据加载器，来加载数据集。使用torch.utils.data.DataLoader()来划分每个batch用来后面训练的时候向网络提供输入数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=32,\n",
    "                                            shuffle=True, pin_memory=True, num_workers=0)\n",
    "test_loader = torch.utils.data.DataLoader(test_ds, batch_size=32,\n",
    "                                            shuffle=True, pin_memory=True, num_workers=0)\n",
    "## numworkers设置不为0 会报错 Broken pipe Error 网上说是win10上的pytorch bug"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_train_loader = torch.utils.data.DataLoader(new_train_ds, batch_size=32,\n",
    "                                            shuffle=True, pin_memory=True, num_workers=0)\n",
    "validate_loader = torch.utils.data.DataLoader(validate_ds, batch_size=32,\n",
    "                                            shuffle=True, pin_memory=True, num_workers=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "加载过后数据形状从三维变成四维，多的维度是batch_size，这里是32个样本构成一个batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32, 3, 224, 224])\n"
     ]
    }
   ],
   "source": [
    "for i, item in enumerate(train_loader):\n",
    "#     pass\n",
    "    print(item[0].shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### resize后的图像查看\n",
    "前面提到过对数据进行了resize和正则化的处理，下面是对处理后的图像的可视化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "img_PIL_Tensor = train_ds[1][0]\n",
    "new_img_PIL = transforms.ToPILImage()(img_PIL_Tensor).convert('RGB')\n",
    "plt.imshow(new_img_PIL)\n",
    "plt.show()\n",
    "# print(new_img_PIL.show())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 网络搭建\n",
    "网络搭建的框架与之前的[手写数字识别](https://zhuanlan.zhihu.com/p/112829371)的框架一致，两个卷积层后3个全连接层。需要注意的是参数不能套用之前的参数了，因为之前的手写数字的图片很小，而且数据量不大所以尽管参数比较大，也能在我的机子上跑起来(MX150,2GB显存)。猫狗的数据量显然比之前的大，所以需要将参数变小些，才能跑起来。 我实验了下，如果不将网络参数降低的话，只调整batch_size没有用，依然会报显存不足。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn.functional as F\n",
    "class MyCNN(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MyCNN,self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3,8,kernel_size=3,stride=1,padding=1) # 按照公式计算后经过卷积层不改变尺寸\n",
    "        self.pool = nn.MaxPool2d(2,2) # 2*2的池化 池化后size 减半\n",
    "        self.conv2 = nn.Conv2d(8,16,kernel_size=3,stride=1,padding=1)\n",
    "        self.fc1 = nn.Linear(16*56*56,256)#两个池化，所以是224/2/2=56\n",
    "        self.fc2 = nn.Linear(256,64)\n",
    "        self.fc3 = nn.Linear(64,2)\n",
    "#         self.dp = nn.Dropout(p=0.5)\n",
    "    def forward(self,x):\n",
    "#         print(\"input:\", x)\n",
    "        x = self.pool(F.relu(self.conv1(x)))\n",
    "#         print(\"first conv:\", x)\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "#         print(\"second conv:\", x)\n",
    "             \n",
    "        x = x.view(-1, 16 * 56* 56)#将数据平整为一维的 \n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))  \n",
    "        x = self.fc3(x)  \n",
    "#         x = F.log_softmax(x,dim=1) NLLLoss()才需要，交叉熵不需要\n",
    "        return x\n",
    "        \n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 预训练模型\n",
    "除了自己手动DIY一个网络，也可以使用Pytorch已经提供的一些性能很好的模型比如VGG16，ResNet50等等，然后微调下网络结构，来得到符合自己的任务的网络架构。还可以直接下载这些模型在ImageNet上的预训练参数，然后在自己的数据集上进行训练。\n",
    "\n",
    "我在这儿选择了ResNet50网络以及预训练好的权重进行了下实验，我在实验室的机器上面用P100跑的，因为自己的笔记本显卡太垃圾了只有2GB显存。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 直接设置为True的话下载权重太慢了\n",
    "## 所以手动用浏览器下载好了之后再重新加载\n",
    "resnet50 = models.resnet50(pretrained=False)  \n",
    "model_path = 'D:/AIdata/dog vs cat/resnet50-19c8e357.pth'\n",
    "resnet50.load_state_dict(torch.load(model_path))\n",
    "resnet50.fc = nn.Linear(2048, 2) #修改最后一层网络将输出调整为两维"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 损失函数和优化函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = MyCNN()\n",
    "# net = resnet50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "# criterion = nn.BCELoss()  #二分类交叉熵损失函数\n",
    "# criterion = nn.BCEWithLogitsLoss() #二分类交叉熵损失函数 带log loss\n",
    "# criterion = nn.MSELoss()\n",
    "\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)\n",
    "#也可以选择Adam优化方法\n",
    "# optimizer = torch.optim.Adam(net.parameters(),lr=1e-2)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  训练日志的打印\n",
    "\n",
    "在之前的手写数字识别的准确率的计算和画图以日志的打印比较简单，在这更新为topk准确率以及使用tensorboard来画曲线。并且使用tqdm进度条来实时的打印日志。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "专门建立一个类来保存和更新准确率的结果，使用类来让代码更加的规范化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AvgrageMeter(object):\n",
    "\n",
    "    def __init__(self):\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        self.avg = 0\n",
    "        self.sum = 0\n",
    "        self.cnt = 0\n",
    "\n",
    "    def update(self, val, n=1):\n",
    "        self.sum += val * n\n",
    "        self.cnt += n\n",
    "        self.avg = self.sum / self.cnt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 准确率的计算\n",
    "torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor) 返回某一维度前k个的索引\n",
    "input：一个tensor数据\n",
    "k：指明是得到前k个数据以及其index\n",
    "dim： 指定在哪个维度上排序， 默认是最后一个维度\n",
    "largest：如果为True，按照大到小排序； 如果为False，按照小到大排序\n",
    "sorted：返回的结果按照顺序返回\n",
    "out：可缺省，不要"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "## topk的准确率计算\n",
    "def accuracy(output, label, topk=(1,)):\n",
    "    maxk = max(topk) \n",
    "    batch_size = label.size(0)\n",
    "    \n",
    "    # 获取前K的索引\n",
    "    _, pred = output.topk(maxk, 1, True, True) #使用topk来获得前k个的索引\n",
    "    pred = pred.t() # 进行转置\n",
    "    # eq按照对应元素进行比较 view(1,-1) 自动转换到行为1,的形状， expand_as(pred) 扩展到pred的shape\n",
    "    # expand_as 执行按行复制来扩展，要保证列相等\n",
    "    correct = pred.eq(label.view(1, -1).expand_as(pred)) # 与正确标签序列形成的矩阵相比，生成True/False矩阵\n",
    "#     print(correct)\n",
    "\n",
    "    rtn = []\n",
    "    for k in topk:\n",
    "        correct_k = correct[:k].view(-1).float().sum(0) # 前k行的数据 然后平整到1维度，来计算true的总个数\n",
    "        rtn.append(correct_k.mul_(100.0 / batch_size)) # mul_() ternsor 的乘法  正确的数目/总的数目 乘以100 变成百分比\n",
    "    return rtn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### tensorboard画图\n",
    "详细的参数讲解参考：https://www.pytorchtutorial.com/pytorch-builtin-tensorboard/ \n",
    "在使用pip install安装tensorboard如果速度很慢经常断线的话可以换个国内的源：\n",
    "`pip config set global.index-url https://mirrors.ustc.edu.cn/pypi/web/simple `"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# tesnor 图片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter \n",
    "writer = SummaryWriter('./tensorboard/')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 迭代训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train( epochs, train_loader, device, model, criterion, optimizer,tensorboard_path):\n",
    "    model = model.to(device)\n",
    "    for epoch in range(epochs):\n",
    "        train_loader = tqdm(train_loader)\n",
    "        train_loss = 0.0\n",
    "        model.train()\n",
    "        top1 = AvgrageMeter()\n",
    "        train_loader.set_description('[%s%04d/%04d %s%f]' % ('Epoch:', epoch + 1, epochs, 'lr:', 0.001))\n",
    "        for i, data in enumerate(train_loader, 0):  # 0是下标起始位置默认为0\n",
    "            inputs, labels = data[0].to(device), data[1].to(device)\n",
    "            # 初始为0，清除上个batch的梯度信息\n",
    "            optimizer.zero_grad()\n",
    "            outputs = model(inputs)\n",
    "            loss = criterion(outputs,labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            #topk准确率\n",
    "            prec1, prec2 = accuracy(outputs, labels, topk=(1, 2))\n",
    "            n = inputs.size(0)\n",
    "            top1.update(prec1.item(), n)\n",
    "            train_loss += loss.item()\n",
    "            postfix = {'train_loss': '%.6f' % (train_loss / (i + 1)), 'train_acc': '%.6f' % top1.avg}\n",
    "            train_loader.set_postfix(log=postfix)\n",
    "\n",
    "            # ternsorboard 曲线绘制\n",
    "            writer = SummaryWriter(tensorboard_path)\n",
    "            writer.add_scalar('Train/Loss', loss.item(), epoch)\n",
    "            writer.add_scalar('Train/Accuracy', top1.avg, epoch)\n",
    "            writer.flush()\n",
    "\n",
    "    print('Finished Training')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  模型评估\n",
    "准确率验证\n",
    "在验证集上面的验证，求网络的的准确率指标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate(validate_loader, device, model, criterion):\n",
    "    val_acc = 0.0\n",
    "    model = model.to(device)\n",
    "    model.eval()\n",
    "    with torch.no_grad():  # 进行评测的时候网络不更新梯度\n",
    "        val_top1 = AvgrageMeter()\n",
    "        validate_loader = tqdm(validate_loader)\n",
    "        validate_loss = 0.0\n",
    "        for i, data in enumerate(validate_loader, 0):  # 0是下标起始位置默认为0\n",
    "            inputs, labels = data[0].to(device), data[1].to(device)\n",
    "            #         inputs,labels = data[0],data[1]\n",
    "            outputs = model(inputs)\n",
    "            loss = criterion(outputs, labels)\n",
    "\n",
    "            prec1, prec2 = accuracy(outputs, labels, topk=(1, 2))\n",
    "            n = inputs.size(0)\n",
    "            val_top1.update(prec1.item(), n)\n",
    "            validate_loss += loss.item()\n",
    "            postfix = {'validate_loss': '%.6f' % (validate_loss / (i + 1)), 'validate_acc': '%.6f' % val_top1.avg}\n",
    "            validate_loader.set_postfix(log=postfix)\n",
    "        val_acc = val_top1.avg\n",
    "    return val_acc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 输出测试集的预测结果\n",
    "将测试集输入进网络，得到测试集的预测结果，并转换成csv文件，用来提交到Kaggle上进行评分。需要注意的是，因为官网要求给的是图片是狗的概率，需要将网络的输出转成概率值。\n",
    "\n",
    "\n",
    "但实际上测试的时候网络的输出是一正一负的值，不是概率值。这是因为测试的时候没有计算loss ，而softmax这个过程是在计算交叉熵的时候自动计算的，所以在网络架构中最后一层全连接输出后没有softmax计算。因此需要我们手动增加上softmax的过程，这样经过softmax后就可以变成两个概率值了!将图片是狗的概率保存下来，并转成符合官方要求的提交格式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def submission(csv_path,test_loader, device, model):\n",
    "    result_list = []\n",
    "    model = model.to(device)\n",
    "    test_loader = tqdm(test_loader)\n",
    "    with torch.no_grad():  # 进行评测的时候网络不更新梯度\n",
    "        for i, data in enumerate(test_loader, 0):\n",
    "            images, labels = data[0].to(device), data[1].to(device)\n",
    "            outputs = model(images)\n",
    "            softmax_func = nn.Softmax(dim=1)  # dim=1表示行的和为1\n",
    "            soft_output = softmax_func(outputs)\n",
    "            predicted = soft_output[:, 1]\n",
    "            for i in range(len(predicted)):\n",
    "                result_list.append({\n",
    "                    \"id\": labels[i].item(),\n",
    "                    \"label\": predicted[i].item()\n",
    "                })\n",
    "    # 从list转成 dataframe 然后保存为csv文件\n",
    "    columns = result_list[0].keys()\n",
    "    result_dict = {col: [anno[col] for anno in result_list] for col in columns}\n",
    "    result_df = pd.DataFrame(result_dict)\n",
    "    result_df = result_df.sort_values(\"id\")\n",
    "    result_df.to_csv(csv_path, index=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 完整调用流程\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 损失函数和优化方法的确定"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = MyCNN()\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "# criterion = nn.BCELoss()  #二分类交叉熵损失函数\n",
    "# criterion = nn.BCEWithLogitsLoss() #二分类交叉熵损失函数 带log loss\n",
    "# criterion = nn.MSELoss()\n",
    "\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)\n",
    "#也可以选择Adam优化方法\n",
    "# optimizer = torch.optim.Adam(net.parameters(),lr=1e-2)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练过程，需要传入epoch数目，训练数据加载器，设备，网络模型，损失函数，优化方法和tensorboard画图的路径等参数。\n",
    "注意的是如果使用完整的官方训练数据集来训练网络后，用这个网络去在验证集上面验证是没有意义的，因为验证集的数据是从完整训练数据集上面划分出来，所以相当于在用训练数据验证性能。用划分过后的new_train_loader训练的网络在进行验证才有意义。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# train( 1, train_loader, device,net, criterion, optimizer,tensorboard_path) # 完整的训练数据集\n",
    "train( 12, new_train_loader, device,net, criterion, optimizer,tensorboard_path) # 划分80%后的训练数据集"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在训练的时候会用tensorboard保存每个时刻的训练数据，需要新打开一个命令端口输入：\n",
    "`tensorboard --logdir=/path_to_log_dir/ --port 6006` 命令，然后通过在浏览器中输入网址http://localhost:6006/ 来查看"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "模型的保存和加载"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.save(net.state_dict(), model_save_path)\n",
    "val_net = MyCNN()\n",
    "val_net.load_state_dict(torch.load(model_save_path))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "验证过程，输入的网络是上面训练过的网络，或者从模型权重保存路径加载的模型。输出模型在自己划分的验证集上面的准确率，结果是98.84%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d9fbdf1d33eb4fc895f556bd8c1f1d29",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=157), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "73.56"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "validate(validate_loader,device,val_net,criterion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "输出测试集预测结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ca03a16cd42942a296d06555ed0d91d5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=391), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "submission('./test.csv',test_loader, device, val_net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后在Kaggle上提交预测结果csv文件，得到打分。 需要先报名参赛这些操作，而且只有Dogs vs. Cats Redux: Kernels Edition这个才能够提交数据，最开始的那个6年前的提交通道已经关闭了。提交可以下载Kaggle的API在命令行提交，也可以直接在[提交链接](https://www.kaggle.com/c/dogs-vs-cats-redux-kernels-edition/submit)提交"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 结果\n",
    "我总共训练了三个网络，其中full_net 使用全部的训练数据，val_net使用划分过的训练数据，RestNet50是预训练的模型，使用完整训练数据训练"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 问题\n",
    "自己在搭建网络的时候遇到一个问题就是随便设置的一个网络结构的时候，发现交叉熵的loss会一直维持在0.69，不下降。暂时还没有搞懂问题出在哪儿，后面有时间了研究下，"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 参考\n",
    "https://www.pytorchtutorial.com/pytorch-builtin-tensorboard/ tensorboard画图\n",
    "https://www.zhihu.com/question/38341743 源的更新\n",
    "https://www.cnblogs.com/marsggbo/p/10496696.html 数据集的划分\n",
    "https://github.com/ShunLu91/Single-Path-One-Shot-NAS topk的计算"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
